#include <GL/glut.h>


#define GLM_MAX_TEXTURES 100
#ifndef M_PI
#define M_PI 3.14159265
#endif

#define GLM_NONE     (0)			/* render with only vertices */
#define GLM_FLAT     (1 << 0)		/* render with facet normals */
#define GLM_SMOOTH   (1 << 1)		/* render with vertex normals */
#define GLM_TEXTURE  (1 << 2)		/* render with texture coords */
#define GLM_COLOR    (1 << 3)		/* render with colors */
#define GLM_MATERIAL (1 << 4)		/* render with materials */


/* 
 * GLMmaterial: Structure that defines a material in a model. 
 */
typedef struct _GLMmaterial {
	char* name;					/* name of material */
	GLfloat diffuse[4];			/* diffuse component */
	GLfloat ambient[4];			/* ambient component */
	GLfloat specular[4];		/* specular component */
	GLfloat emmissive[4];		/* emmissive component */
	GLfloat shininess;			/* specular exponent */
	GLuint	IDTexture;			/* id of texture use for material */
} GLMmaterial;

/* 
 * GLMtriangle: Structure that defines a triangle in a model.
 */
typedef struct _GLMtriangle {
	GLuint vindices[3];			/* array of triangle vertex indices */
	GLuint nindices[3];			/* array of triangle normal indices */
	GLuint tindices[3];			/* array of triangle texcoord indices*/
	GLuint findex;				/* index of triangle facet normal */
} GLMtriangle;

/* 
 * GLMgroup: Structure that defines a group in a model.
 */
typedef struct _GLMgroup {
	char*             name;			/* name of this group */
	GLuint            numtriangles;	/* number of triangles in this group */
	GLuint*           triangles;	/* array of triangle indices */
	GLuint            material;     /* index to material for group */
	struct _GLMgroup* next;			/* pointer to next group in model */
} GLMgroup;

typedef struct _GLMtexture {
  char *name;
  GLuint id;                    
  GLfloat width;		
  GLfloat height;
} GLMtexture;


/* 
 * GLMmodel: Structure that defines a model.
 */
typedef struct _GLMmodel {
	char*    pathname;			/* path to this model */
	char*    mtllibname;		/* name of the material library */

	GLfloat translacao[3];      /* coordenadas de translacao do objecto  */
	GLfloat escala[3];          /* coordenadas de escala do objecto  */
	GLfloat rotacao[4];         /* coordenadas de rotacao do objecto  */

	GLuint   numvertices;		/* number of vertices in model */
	GLfloat* vertices;			/* array of vertices  */

	GLuint   numnormals;		/* number of normals in model */
	GLfloat* normals;			/* array of normals */

	GLuint   numtexcoords;		/* number of texcoords in model */
	GLfloat* texcoords;			/* array of texture coordinates */

	GLuint   numfacetnorms;		/* number of facetnorms in model */
	GLfloat* facetnorms;		/* array of facetnorms */

	GLuint   numtriangles;		/* number of triangles in model */
	GLMtriangle* triangles;		/* array of triangles */

	GLuint       nummaterials;		/* number of materials in model */
	GLMmaterial* materials;		/* array of materials */

	GLuint       numgroups;		/* number of groups in model */
	GLMgroup*    groups;			/* linked list of groups */
	
	GLuint       numtextures;
	GLMtexture*  textures;

	GLfloat position[3];			/* position of the model */

} GLMmodel;

// funcoes adicionadas
GLvoid relScale(GLMmodel* model, GLfloat scalex, GLfloat scaley, GLfloat scalez);

GLvoid relTrans(GLMmodel* model, GLfloat transx, GLfloat transy, GLfloat transz);

GLvoid relRotat(GLMmodel* model, GLfloat angle, GLfloat rotatex, GLfloat rotatey, GLfloat rotatez);

//fim

/* 
 * glmUnitize: "unitize" a model by translating it to the origin and
 * scaling it to fit in a unit cube around the origin.  Returns the
 * scalefactor used.
 *
 * model - properly initialized GLMmodel structure 
 */
GLfloat glmUnitize(GLMmodel* model);

/* glmDimensions: Calculates the dimensions (width, height, depth) of
* a model.
*
* model      - initialized GLMmodel structure
* dimensions - array of 3 GLfloats (GLfloat dimensions[3])
*/
GLvoid glmDimensions(GLMmodel* model, GLfloat* dimensions);

/* glmScale: Scales a model by a given amount.
* 
* model - properly initialized GLMmodel structure
* scale - scalefactor (0.5 = half as large, 2.0 = twice as large)
*/
GLvoid glmScale(GLMmodel* model, GLfloat scale);

/* glmReverseWinding: Reverse the polygon winding for all polygons in
* this model.  Default winding is counter-clockwise.  Also changes
* the direction of the normals.
* 
* model - properly initialized GLMmodel structure 
*/
GLvoid glmReverseWinding(GLMmodel* model);

/* glmFacetNormals: Generates facet normals for a model (by taking the
* cross product of the two vectors derived from the sides of each
* triangle).  Assumes a counter-clockwise winding.
*
* model - initialized GLMmodel structure
*/
GLvoid glmFacetNormals(GLMmodel* model);

/* glmVertexNormals: Generates smooth vertex normals for a model.
* First builds a list of all the triangles each vertex is in.  Then
* loops through each vertex in the the list averaging all the facet
* normals of the triangles each vertex is in.  Finally, vectors the
* normal index in the triangle for the vertex to the generated smooth
* normal.  If the dot product of a facet normal and the facet normal
* associated with the first triangle in the list of triangles the
* current vertex is in is greater than the cosine of the angle
* parameter to the function, that facet normal is not added into the
* average normal calculation and the corresponding vertex is given
* the facet normal.  This tends to preserve hard edges.  The angle to
* use depends on the model, but 90 degrees is usually a good start.
*
* model - initialized GLMmodel structure
* angle - maximum angle (in degrees) to smooth across
*/
GLvoid glmVertexNormals(GLMmodel* model, GLfloat angle);

/* glmLinearTexture: Generates texture coordinates according to a
* linear projection of the texture map.  It generates these by
* linearly mapping the vertices onto a square.
*
* model - pointer to initialized GLMmodel structure
*/
GLvoid glmLinearTexture(GLMmodel* model);

/* glmSpheremapTexture: Generates texture coordinates according to a
* spherical projection of the texture map.  Sometimes referred to as
* spheremap, or reflection map texture coordinates.  It generates
* these by using the normal to calculate where that vertex would map
* onto a sphere.  Since it is impossible to map something flat
* perfectly onto something spherical, there is distortion at the
* poles.  This particular implementation causes the poles along the X
* axis to be distorted.
*
* model - pointer to initialized GLMmodel structure
*/
GLvoid glmSpheremapTexture(GLMmodel* model);

/* glmDelete: Deletes a GLMmodel structure.
*
* model - initialized GLMmodel structure
*/
GLvoid glmDelete(GLMmodel* model);

/* glmReadOBJ: Reads a model description from a Wavefront .OBJ file.
* Returns a pointer to the created object which should be free'd with
* glmDelete().
*
* filename - name of the file containing the Wavefront .OBJ format data.  
*/
GLMmodel* glmReadOBJ(char* filename);

/* glmWriteOBJ: Writes a model description in Wavefront .OBJ format to
* a file.
*
* model    - initialized GLMmodel structure
* filename - name of the file to write the Wavefront .OBJ format data to
* mode     - a bitwise or of values describing what is written to the file
*            GLM_NONE    -  write only vertices
*            GLM_FLAT    -  write facet normals
*            GLM_SMOOTH  -  write vertex normals
*            GLM_TEXTURE -  write texture coords
*            GLM_FLAT and GLM_SMOOTH should not both be specified.
*/
GLvoid glmWriteOBJ(GLMmodel* model, char* filename, GLuint mode);

/* glmDraw: Renders the model to the current OpenGL context using the
* mode specified.
*
* model    - initialized GLMmodel structure
* mode     - a bitwise OR of values describing what is to be rendered.
*            GLM_NONE    -  render with only vertices
*            GLM_FLAT    -  render with facet normals
*            GLM_SMOOTH  -  render with vertex normals
*            GLM_TEXTURE -  render with texture coords
*            GLM_FLAT and GLM_SMOOTH should not both be specified.
*/
GLvoid glmDraw(GLMmodel* model, GLuint mode);

/* glmList: Generates and returns a display list for the model using
* the mode specified.
*
* model    - initialized GLMmodel structure
* mode     - a bitwise OR of values describing what is to be rendered.
*            GLM_NONE    -  render with only vertices
*            GLM_FLAT    -  render with facet normals
*            GLM_SMOOTH  -  render with vertex normals
*            GLM_TEXTURE -  render with texture coords
*            GLM_FLAT and GLM_SMOOTH should not both be specified.  
*/
GLuint glmList(GLMmodel* model, GLuint mode);

/* glmWeld: eliminate (weld) vectors that are within an epsilon of
* each other.
*
* model      - initialized GLMmodel structure
* epsilon    - maximum difference between vertices
*              ( 0.00001 is a good start for a unitized model)
*
*/
GLvoid glmWeld(GLMmodel* model, GLfloat epsilon);

/*
 * glmAddTexture: add texture from file 
 * 
 * szTexturePath	- path to texture file
 */
GLuint glmAddTexture(GLMmodel *model, char* szTexturePath);

GLuint glmLoadTexture(char *filename, GLboolean alpha, GLboolean repeat, GLboolean filtering, GLboolean mipmaps, GLfloat *texcoordwidth, GLfloat *texcoordheight);